// var common = require("./public.js");
const config = require('./config.js')
const app = getApp()
module.exports = {
  regionId:'1912',
  HttpUrl: 'https://api.feiyanghy.com',
//   HttpUrl: 'http://47.103.92.96:80', 
  // HttpUrl: 'http://apitest.feiyang.life',
  // payHttpUrl: "https://www.feiyangwang.xin",
  payHttpUrl: 'https://order.feiyanghy.com',
  /**            
   * 显示弹框
   * @param {string} title 标题
   * @param {string} content 内容
   * @param {function} callback 回调函数，参数为点击成功返回true，点击取消返回false
   * @param {string} confirmText 确认按钮文字，默认为确认
   * @param {string} cancelText 取消按钮文字，默认为取消
   */
  showAlertView(title, content, callback, confirmText = '确认', cancelText = '取消') {
    wx.showModal({
      title,
      content,
      cancelColor: '#ccc',
      cancelText,
      confirmColor: '#e70012',
      confirmText,
      showCancel: true,
      success: (result) => {
        if (result.confirm) {
          callback(true)
        } else {
          callback(false)
        }
      },
      fail: (result) => { }
    })
  },
  // 封装的get请求，请求体格式为字符串拼接
  get(url, data = {}, success, loadfinish) {
    this.wxRequest(url, 'GET', data, 'application/x-www-form-urlencoded', success, loadfinish)
  },
  // 封装的post请求，请求体格式为字符串拼接
  post(url, data = {}, success, loadfinish) {
    this.wxRequest(url, 'POST', data, 'application/x-www-form-urlencoded', success, loadfinish)
  },
  // 封装的post请求，请求体格式为json格式
  postJson(url, data = {}, success, loadfinish) {
    this.wxRequest(url, 'POST', data, 'application/json', success, loadfinish)
  },
  // 封装的get请求，请求体格式为json格式
  getJson(url, data = {}, success, loadfinish) {
    this.wxRequest(url, 'GET', data, 'application/json', success, loadfinish)
  },
  /**
   * 封装微信提供的网络请求接口，本方法为私有方法，外部使用请使用上面提供的get、post封装
   * @param {string} url 请求路径
   * @param {string} method 请求方法
   * @param {object} data 请求参数
   * @param {string} contentType 请求类型
   * @param {function} callback 请求成功（httpstatue为200）的回调
   * @param {function} loadfinish 请求结束的回调（成功和失败都会回调）
   * @discussion 由于部分接口在请求失败(如没有收藏返回的是非200)的时候不需要提示，这个接口里面没有做统一的异常处理
   */
  wxRequest(url, method, data = {}, contentType, callback, loadfinish = () => { }) {
    wx.request({
      url: this.HttpUrl + url,
      method,
      data,
      timeout: 60000,
      header: {
        'content-type': contentType
      },
      success: (response) => {
          console.log('response---',response);
        if (response && response.statusCode !== 200) {
          this.showToast('您的网络开小差了，请稍后再试 - ' + response.statusCode)
          loadfinish()
          return
        }
        let responseType = 0 // 正常数据
        if (response) {
          // 下面的登录过期，未实名的处理方式并不好，接口设计不合理
          if (response.data.msg == '用户登陆已过期') { //重新登录
            wx.removeStorageSync('user')
            this.showLoginPage('您的登录已过期，请重新登录吧~')
            responseType = 1
          } else if (response.data.msg == '用户还没实名认证，请实名后在购买' || response.data.msg == '用户未实名') {
            this.toRealName()
          } else {
            callback(response.data)
          }
        } else {
          // 没有获得到响应，提示异常
          this.showToast('您的网络开小差了，请稍后再试')
        }
        // 在处理完数据后，调用加载完成回调
        loadfinish(responseType)
      },
      fail: (res) => {
        loadfinish()
        this.showToast('您的网络开小差了，请稍后再试')
      }
    })
  },
  /**
   * 封装的微信支付
   * @param {String} url 请求路径
   * @param {Object} param 请求参数
   * @param {Function} callback 请求成功回调
   * @param {Function} finish 请求结束回调，成功或失败都会回调
   */
  wxPayRequest(url, param, callback, finish = function () { }) {
    const that = this
    wx.request({
      url: this.payHttpUrl + url,
      method: 'POST',
      data: param,
      timeout: 10000,
      header: {
        'content-type': 'application/x-www-form-urlencoded',
      },
      success(res) {
        if (!res || res.statusCode != 200) {
          that.showToast('您的网络开小差了，请稍后再试 - ' + res.statusCode)
        } else {
          // http响应码为200
          if (res.data.msg == '登录已超时，请重新登录') { //重新登录
            wx.clearStorage({
              success: function () {
                that.showLoginPage('登录已超时，请重新登录')
              }
            })
          } else if (res.msg == '请先实名认证') {
            that.toRealName(false)
          } else {
            callback(res.data)
          }
        }

        finish()
      },
      fail: function (err) {
        finish()
        that.showToast('您的网络开小差了，请稍后再试')
      }
    });
  },
  /**
   * 防重复点击方法
   * @param {function} func 需要实现的函数
   * @param {number} marginTime 防重复点击的时间
   */
  throttleFunc: function throttleFunc(func, marginTime) {
    if (marginTime == undefined || marginTime == null) {
      marginTime = 1500
    }
    let lastTime = null
    return function () {
      let currentTime = +new Date()
      if (currentTime - lastTime > marginTime || !lastTime) {
        func.apply(this, arguments)
        lastTime = currentTime
      }
    }
  },
  /**
   * 登录函数
   * @param {string} back 登录成功后的返回url，默认为null，返回到当前页面
   */
  loginFunc(back = null,validateCode) {
    const that = this
    return new Promise((resolve, reject) => {
      wx.login({
        success: function (loginRes) {
          if (loginRes && loginRes.code && loginRes.code != '') {
            const tempJson = {
              code: loginRes.code,
              validateCode:validateCode  //验证码
            }
            // that.getJson('/user/wxxcx/login', tempJson, function (res) { 原来
               that.getJson('/user/wxxcx/loginUseValidate ', tempJson, function (res) { 
                 console.log(res,"resres")
              if (res.status == '400' || res.status == '401') { // 没有手机号，但是有unionId
                app.globalData.unionId = res.data.unionId
                app.globalData.openid = res.data.openid
                // 新用户，有unionId,跳转手机授权页面
                let backUrl = back
                if (!backUrl) {
                  backUrl = that.getCurrentPageUrlWithArgs()
                }
                // 重定向页面，返回链接包含页面参数
                wx.redirectTo({
                  url: '/pages/ZBAuthorize/index?backUrl=' + encodeURIComponent(backUrl),
                })
              } else if (res.status == '200') { //非新用户
                wx.setStorage({
                  key: 'user',
                  data: res.data,
                  success: function () {
                    resolve(true)
                  }
                })
              } else {
                that.showRequestErrMsg(res)
              }
            })
          }
        },
        fail: (err) => {
          reject(err)
        }
      })
    })
  },
  /**
   * 显示请求异常信息
   * @param {object} res 响应数据
   */
  showRequestErrMsg(res) {
    this.showToast(res.msg ? res.msg : '您的网络开小差了~')
  },
  /**
   * 封装微信的轻提示
   * @param {string} title 标题
   * @param {string} icon 提示图标，默认为none，不显示图标
   * @param {number} duration 显示时长，单位毫秒，默认为1500毫秒
   */
  showToast(title, icon = 'none', duration = 1500) {
    wx.showToast({
      title,
      icon,
      duration
    })
  },
  /**
   * 显示登录页面
   * @param {string} content 提示信息
   */
  showLoginPage(content = null) {
    // 重定向页面，返回链接包含页面参数
    const pages = getCurrentPages()
    console.log(pages,"getCurrentPages")
    const currPage = pages[pages.length - 1]  //当前页面
    // 当前是在登录页面，不再需要跳转
    if (currPage.route === 'pages/login/index') {
      return
    }
    const backUrl = this.getCurrentPageUrlWithArgs()  //来时页面
    const myUrl = config.myCenterUrl ? config.myCenterUrl : 'pages/mySelf/Index/index'
    // 这里需要区分是从哪个页面跳转的
    if (currPage.route === myUrl) {
      wx.navigateTo({
        url: '/pages/login/index',
        success: (res) => {
          if (content) {
            this.showToast(content, 'none', 2500)
          }
        }
      })
    } else {
   
      wx.redirectTo({
        url: '/pages/login/index?backUrl=' + encodeURIComponent(backUrl),
        success: (res) => {
          if (content) {
            this.showToast(content)
          }
        }
      })
    }
  },
  /**
   * 跳转到商品详情页面
   * @param {object} item 商品参数
   * @param {string} param 额外参数，格式为'&key=value'
   */
  gotoGoodsPage(item, param = '') {
    const idx = item.id
    const title = item.title ? item.title : ''
    const image = item.image
    const sellPoint = item.sellPoint ? item.sellPoint : ''
    wx.navigateTo({
      url: '/packageA/pages/Goods/GoodsDes/index?id=' + idx + '&name=' + title + '&image=' + image +
        '&sellPoint=' + sellPoint + param,
    })
  },
  /**
   * 跳转到店铺页面
   * @param {object} item 店铺参数
   * @param {string} param 额外参数，格式为'&key=value'
   */
  gotoStore(item, param = '') {
    const idx = item.storeId ? item.storeId : item.id // 兼容不同页面...
    const storeName = item.storeName ? item.storeName : item.name // 兼容不同页面...
    const storeImage = item.storeImage ? item.storeImage : ''
    const storeTypeName = item.storeTypeName ? item.storeTypeName : ''

    if (storeTypeName == '景区景点' || storeTypeName == '体育场馆') {
      wx.navigateTo({
        url: '/pages/ScenicArea/ScenicAreaMainPage/index?id=' + idx + '&moduleType=1'
        + '&storeTypeName=' + storeTypeName,
      })
    }else{
      wx.navigateTo({
        url: '/packageA/pages/Goods/storePage/index?id=' + idx +
          '&storeName=' + storeName +
          '&storeImage=' + storeImage + param
      })
    }

  },
  /**
   * 跳转到实名认证页面
   * @param {boolean} hasArgs 是否包含返回参数，包含返回参数，实名认证成功后会返回当前页面
   */
  toRealName(hasArgs = true) {
    const content = '您还未实名，请前往实名认证吧~'
    this.showAlertView(
      '温馨提示',
      content,
      (conform) => {
        if (conform) {
          let backUrl = this.getCurrentPageUrlWithArgs()
          if (hasArgs) {
            wx.redirectTo({
              url: '/pages/realIdent/index?backUrl=' + encodeURIComponent(backUrl),
            })
          } else {
            wx.navigateTo({
              url: '/pages/realIdent/index',
            })
          }
        }
      },
      '去实名',
      '暂不实名')
  },
  /**
   * 获取当前页面Url和参数
   */
  getCurrentPageUrlWithArgs() {
    const pages = getCurrentPages()
    console.log(pages,"getCurrentPages")
    const currentPage = pages[pages.length - 1]  //当前页面
    console.log(currentPage,"测试测试测试")
    const url = currentPage.route  //从哪个页面跳过去的
    const options = currentPage.options
    let urlWithArgs = `/${url}?`

    for (let key in options) {
      const value = options[key]
      console.log(value)
      urlWithArgs += `${key}=${value}&`  //字符拼接
    
    }
    urlWithArgs = urlWithArgs.substring(0, urlWithArgs.length - 1)
    return urlWithArgs
  },
  /**
   * 获取指定日期的周历
   * @param {number} date 时间戳
   */
  getWeekDate(date) {
    let now = new Date(date)
    let day = now.getDay()
    let weeks = ['周日', '周一', '周二', '周三', '周四', '周五', '周六']
    let week = weeks[day]
    return week
  },
  /**
   * 格式化日期
   * @param {string} fmt 格式化字符串
   * @param {number} adate 日期
   */
  dateFormat(fmt, adate,aa=0) {
    // yyyy-MM-dd HH:mm:ss
    let ret
   
    let date = new Date(adate)
  
    date.setDate(date.getDate() + aa);
    const opt = {
      "M+": (date.getMonth() + 1).toString(), // 月
      "d+": date.getDate().toString(), // 日
      "H+": date.getHours().toString(), // 时
      "m+": date.getMinutes().toString(), // 分
      "s+": date.getSeconds().toString() // 秒
    }
    if (/(y+)/.test(fmt)) fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
    for (let k in opt) {
      ret = new RegExp('(' + k + ')').exec(fmt)
      if (ret) {
        let value = (ret[1].length == 1) ? (opt[k]) : (('00' + opt[k]).substr(('' + opt[k]).length))
        fmt = fmt.replace(ret[1], value)
      }
    }
    return fmt
  },
  /**
   * 获取本地用户信息
   * @param {function} complete 完成回调，获取成功或失败都会回调，第一个参数为获取状态，成功为true，失败为false，第二个参数为用户信息对象
   * @param {Boolean} needLogin 是否需要登录，默认为false
   * @description 示例，获取用户token和userId，未登录则跳转登录
   * getLocalUserInfo((success, data) => {
   *  if(success) {
   *    this.data.userId = data.user.id
   *    this.data.token = data.token
   *  }
   * }, true)
   */
  getLocalUserInfo(complete = () => { }, needLogin = false) {
    wx.getStorage({
      key: 'user',
      success: (res) => {
        complete(true, res.data)
      },
      fail: () => {
        complete(false, null)
        needLogin && this.showLoginPage()
      }
    })
  },
  /**`-----------------+
   * 判断当前字符串是否为空
   * @param {object} obj 需要判断的对象
   */
  isEmptyString(obj) {
    if (typeof obj == 'undefined' || obj === null || obj === '') {
      return true
    } else {
      return false
    }
  }
}